{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# #从OBS桶下载数据集\n",
    "# !wget https://professional-construction.obs.cn-north-4.myhuaweicloud.com:443/deep-learning/fashion-mnist.zip\n",
    "# #解压文件\n",
    "# !unzip fashion-mnist.zip"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import struct\n",
    "import sys\n",
    "from easydict import EasyDict as edict\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "import mindspore\n",
    "import mindspore.dataset as ds\n",
    "import mindspore.nn as nn\n",
    "from mindspore import context\n",
    "from mindspore.nn.metrics import Accuracy\n",
    "from mindspore.train import Model\n",
    "from mindspore.train.callback import ModelCheckpoint, CheckpointConfig, LossMonitor, TimeMonitor\n",
    "from mindspore import Tensor\n",
    "\n",
    "context.set_context(mode=context.GRAPH_MODE, device_target='Ascend')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "cfg = edict({\n",
    "    'train_size': 60000,  # 训练集大小\n",
    "    'test_size': 10000,  # 测试集大小\n",
    "    'channel': 1,  # 图片通道数\n",
    "    'image_height': 28,  # 图片高度\n",
    "    'image_width': 28,  # 图片宽度\n",
    "    'batch_size': 64,\n",
    "    'num_classes': 10,  # 分类类别\n",
    "    'lr': 0.001,  # 学习率\n",
    "    'epoch_size': 20,  # 训练次数\n",
    "    'data_dir_train': os.path.join('fashion-mnist', 'train'),\n",
    "    'data_dir_test': os.path.join('fashion-mnist', 'test'),\n",
    "})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def read_image(file_name):\n",
    "    '''\n",
    "    :param file_name: 文件路径\n",
    "    :return:  训练或者测试数据\n",
    "    如下是训练的图片的二进制格式\n",
    "    [offset] [type]          [value]          [description]\n",
    "    0000     32 bit integer  0x00000803(2051) magic number\n",
    "    0004     32 bit integer  60000            number of images\n",
    "    0008     32 bit integer  28               number of rows\n",
    "    0012     32 bit integer  28               number of columns\n",
    "    0016     unsigned byte   ??               pixel\n",
    "    0017     unsigned byte   ??               pixel\n",
    "    ........\n",
    "    xxxx     unsigned byte   ??               pixel\n",
    "    '''\n",
    "    file_handle = open(file_name, \"rb\")  # 以二进制打开文档\n",
    "    file_content = file_handle.read()  # 读取到缓冲区中\n",
    "    head = struct.unpack_from('>IIII', file_content, 0)  # 取前4个整数，返回一个元组\n",
    "    offset = struct.calcsize('>IIII')\n",
    "    imgNum = head[1]  # 图片数\n",
    "    width = head[2]  # 宽度\n",
    "    height = head[3]  # 高度\n",
    "    bits = imgNum * width * height  # data一共有60000*28*28个像素值\n",
    "    bitsString = '>' + str(bits) + 'B'  # fmt格式：'>47040000B'\n",
    "    imgs = struct.unpack_from(bitsString, file_content, offset)  # 取data数据，返回一个元组\n",
    "    imgs_array = np.array(imgs, np.float32).reshape((imgNum, width * height))  # 最后将读取的数据reshape成 【图片数，图片像素】二维数组\n",
    "    return imgs_array\n",
    "\n",
    "\n",
    "def read_label(file_name):\n",
    "    '''\n",
    "    :param file_name:\n",
    "    :return:\n",
    "    标签的格式如下：\n",
    "    [offset] [type]          [value]          [description]\n",
    "    0000     32 bit integer  0x00000801(2049) magic number (MSB first)\n",
    "    0004     32 bit integer  60000            number of items\n",
    "    0008     unsigned byte   ??               label\n",
    "    0009     unsigned byte   ??               label\n",
    "    ........\n",
    "    xxxx     unsigned byte   ??               label\n",
    "    The labels values are 0 to 9.\n",
    "    '''\n",
    "    file_handle = open(file_name, \"rb\")  # 以二进制打开文档\n",
    "    file_content = file_handle.read()  # 读取到缓冲区中\n",
    "    head = struct.unpack_from('>II', file_content, 0)  # 取前2个整数，返回一个元组\n",
    "    offset = struct.calcsize('>II')\n",
    "    labelNum = head[1]  # label数\n",
    "    bitsString = '>' + str(labelNum) + 'B'  # fmt格式：'>47040000B'\n",
    "    label = struct.unpack_from(bitsString, file_content, offset)  # 取data数据，返回一个元组\n",
    "    return np.array(label, np.int32)\n",
    "\n",
    "\n",
    "def get_data():\n",
    "    # 文件获取\n",
    "    train_image = os.path.join(cfg.data_dir_train, 'train-images-idx3-ubyte')\n",
    "    test_image = os.path.join(cfg.data_dir_test, \"t10k-images-idx3-ubyte\")\n",
    "    train_label = os.path.join(cfg.data_dir_train, \"train-labels-idx1-ubyte\")\n",
    "    test_label = os.path.join(cfg.data_dir_test, \"t10k-labels-idx1-ubyte\")\n",
    "    # 读取数据\n",
    "    train_x = read_image(train_image)\n",
    "    test_x = read_image(test_image)\n",
    "    train_y = read_label(train_label)\n",
    "    test_y = read_label(test_label)\n",
    "    return train_x, train_y, test_x, test_y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "训练数据集样本数： 60000\n",
      "测试数据集样本数： 10000\n",
      "通道数/图像长/宽： (1, 28, 28)\n",
      "一张图像的标签样式： 9\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "train_x, train_y, test_x, test_y = get_data()\n",
    "train_x = train_x.reshape(-1, 1, cfg.image_height, cfg.image_width)\n",
    "test_x = test_x.reshape(-1, 1, cfg.image_height, cfg.image_width)\n",
    "train_x = train_x / 255.0\n",
    "test_x = test_x / 255.0\n",
    "\n",
    "print('训练数据集样本数：', train_x.shape[0])\n",
    "print('测试数据集样本数：', test_y.shape[0])\n",
    "print('通道数/图像长/宽：', train_x.shape[1:])\n",
    "print('一张图像的标签样式：', train_y[0])  # 一共10类，用0-9的数字表达类别。\n",
    "\n",
    "plt.figure()\n",
    "plt.imshow(train_x[0,0,...])\n",
    "plt.colorbar()\n",
    "plt.grid(False)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 转换数据类型为Dataset\n",
    "def create_dataset():\n",
    "    XY_train = list(zip(train_x, train_y))\n",
    "    ds_train = ds.GeneratorDataset(XY_train, ['x', 'y'])\n",
    "    ds_train = ds_train.shuffle(buffer_size=1000).batch(cfg.batch_size, drop_remainder=True)\n",
    "    XY_test = list(zip(test_x, test_y))\n",
    "    ds_test = ds.GeneratorDataset(XY_test, ['x', 'y'])\n",
    "    ds_test = ds_test.shuffle(buffer_size=1000).batch(cfg.batch_size, drop_remainder=True)\n",
    "    return ds_train, ds_test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 定义卷积神经网络，无正则化\n",
    "class ForwardFashion(nn.Cell):\n",
    "    def __init__(self, num_class=10):  # 一共分十类，图片通道数是1\n",
    "        super(ForwardFashion, self).__init__()\n",
    "        self.num_class = num_class\n",
    "        self.conv1 = nn.Conv2d(1, 32,kernel_size=3, stride=1, padding=0, has_bias=False, pad_mode=\"valid\")\n",
    "        self.conv2 = nn.Conv2d(32, 64,kernel_size=3, stride=1, padding=0, has_bias=False, pad_mode=\"valid\")\n",
    "        self.conv3 = nn.Conv2d(64, 128,kernel_size=3, stride=1, padding=0, has_bias=False, pad_mode=\"valid\")\n",
    "        self.maxpool2d = nn.MaxPool2d(kernel_size=2, stride=2)\n",
    "        self.relu = nn.ReLU()\n",
    "        self.flatten = nn.Flatten()\n",
    "        self.fc1 = nn.Dense(128 * 11 * 11, 128)\n",
    "        self.fc2 = nn.Dense(128, self.num_class)\n",
    "\n",
    "    def construct(self, x):\n",
    "        x = self.conv1(x)\n",
    "        x = self.relu(x)\n",
    "        x = self.conv2(x)\n",
    "        x = self.relu(x)\n",
    "        x = self.conv3(x)\n",
    "        x = self.relu(x)\n",
    "        x = self.maxpool2d(x)\n",
    "        x = self.flatten(x)\n",
    "        x = self.fc1(x)\n",
    "        x = self.relu(x)\n",
    "        x = self.fc2(x)\n",
    "        return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 定义卷积神经网络，有正则化\n",
    "class ForwardFashionRegularization(nn.Cell):\n",
    "    def __init__(self, num_class=10):  # 一共分十类，图片通道数是1\n",
    "        super(ForwardFashionRegularization, self).__init__()\n",
    "        self.num_class = num_class\n",
    "        self.conv1 = nn.Conv2d(1, 32,kernel_size=3, stride=1, padding=0, has_bias=False, pad_mode=\"valid\")\n",
    "        self.conv2 = nn.Conv2d(32, 64,kernel_size=3, stride=1, padding=0, has_bias=False, pad_mode=\"valid\")\n",
    "        self.conv3 = nn.Conv2d(64, 128,kernel_size=3, stride=1, padding=0, has_bias=False, pad_mode=\"valid\")\n",
    "        self.maxpool2d = nn.MaxPool2d(kernel_size=2, stride=2)\n",
    "        self.relu = nn.ReLU()\n",
    "        self.dropout = nn.Dropout()\n",
    "        self.flatten = nn.Flatten()\n",
    "        self.fc1 = nn.Dense(3200, 128)\n",
    "        self.bn = nn.BatchNorm1d(128)\n",
    "        self.fc2 = nn.Dense(128, self.num_class)\n",
    "\n",
    "    def construct(self, x):\n",
    "        x = self.conv1(x)\n",
    "        x = self.relu(x)\n",
    "        x = self.conv2(x)\n",
    "        x = self.relu(x)\n",
    "        x = self.maxpool2d(x)\n",
    "        x = self.dropout(x)\n",
    "        x = self.conv3(x)\n",
    "        x = self.relu(x)\n",
    "        x = self.maxpool2d(x)\n",
    "        x = self.dropout(x)\n",
    "        x = self.flatten(x)\n",
    "        x = self.fc1(x)\n",
    "        x = self.relu(x)\n",
    "        x = self.bn(x)\n",
    "        x = self.dropout(x)\n",
    "        x = self.fc2(x)\n",
    "        return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train(Net):\n",
    "    ds_train, ds_test = create_dataset()\n",
    "    # 构建网络\n",
    "    network = Net(cfg.num_classes)\n",
    "    # 定义模型的损失函数，优化器\n",
    "    net_loss = nn.SoftmaxCrossEntropyWithLogits(sparse=True, reduction=\"mean\")\n",
    "    net_opt = nn.Adam(network.trainable_params(), cfg.lr)\n",
    "    # 训练模型\n",
    "    model = Model(network, loss_fn=net_loss, optimizer=net_opt, metrics={'acc': Accuracy()})\n",
    "    loss_cb = LossMonitor()\n",
    "    print(\"============== Starting Training ==============\")\n",
    "    model.train(30, ds_train, callbacks=[loss_cb], dataset_sink_mode=True)\n",
    "    # 验证\n",
    "    metric = model.eval(ds_test)\n",
    "    print(metric)\n",
    "    \n",
    "    return model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "============== Starting Training ==============\n",
      "epoch: 1 step: 937, loss is 0.44618028\n",
      "epoch: 2 step: 937, loss is 0.22886054\n",
      "epoch: 3 step: 937, loss is 0.13210446\n",
      "epoch: 4 step: 937, loss is 0.20672263\n",
      "epoch: 5 step: 937, loss is 0.0946552\n",
      "epoch: 6 step: 937, loss is 0.17510523\n",
      "epoch: 7 step: 937, loss is 0.16793618\n",
      "epoch: 8 step: 937, loss is 0.069517665\n",
      "epoch: 9 step: 937, loss is 0.08342023\n",
      "epoch: 10 step: 937, loss is 0.056444228\n",
      "epoch: 11 step: 937, loss is 0.0862963\n",
      "epoch: 12 step: 937, loss is 0.08084622\n",
      "epoch: 13 step: 937, loss is 0.13618313\n",
      "epoch: 14 step: 937, loss is 0.05741894\n",
      "epoch: 15 step: 937, loss is 0.019388027\n",
      "epoch: 16 step: 937, loss is 0.014366223\n",
      "epoch: 17 step: 937, loss is 0.11486755\n",
      "epoch: 18 step: 937, loss is 0.012561982\n",
      "epoch: 19 step: 937, loss is 0.010291649\n",
      "epoch: 20 step: 937, loss is 0.08221265\n",
      "epoch: 21 step: 937, loss is 0.02160878\n",
      "epoch: 22 step: 937, loss is 0.094874114\n",
      "epoch: 23 step: 937, loss is 0.035864547\n",
      "epoch: 24 step: 937, loss is 0.005947893\n",
      "epoch: 25 step: 937, loss is 0.0011435747\n",
      "epoch: 26 step: 937, loss is 0.019845068\n",
      "epoch: 27 step: 937, loss is 0.03429544\n",
      "epoch: 28 step: 937, loss is 0.023285983\n",
      "epoch: 29 step: 937, loss is 0.00012097177\n",
      "epoch: 30 step: 937, loss is 0.010189517\n",
      "{'acc': 0.9120592948717948}\n"
     ]
    }
   ],
   "source": [
    "# 训练无正则化的网络\n",
    "model = train(ForwardFashion)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "============== Starting Training ==============\n",
      "epoch: 1 step: 937, loss is 0.4416728\n",
      "epoch: 2 step: 937, loss is 0.38747072\n",
      "epoch: 3 step: 937, loss is 0.69458747\n",
      "epoch: 4 step: 937, loss is 0.37273443\n",
      "epoch: 5 step: 937, loss is 0.3485953\n",
      "epoch: 6 step: 937, loss is 0.42782623\n",
      "epoch: 7 step: 937, loss is 0.25521576\n",
      "epoch: 8 step: 937, loss is 0.18834415\n",
      "epoch: 9 step: 937, loss is 0.29044598\n",
      "epoch: 10 step: 937, loss is 0.16157377\n",
      "epoch: 11 step: 937, loss is 0.123149574\n",
      "epoch: 12 step: 937, loss is 0.29526472\n",
      "epoch: 13 step: 937, loss is 0.25381514\n",
      "epoch: 14 step: 937, loss is 0.30744857\n",
      "epoch: 15 step: 937, loss is 0.27070445\n",
      "epoch: 16 step: 937, loss is 0.17147373\n",
      "epoch: 17 step: 937, loss is 0.26714\n",
      "epoch: 18 step: 937, loss is 0.16170019\n",
      "epoch: 19 step: 937, loss is 0.16462994\n",
      "epoch: 20 step: 937, loss is 0.23525417\n",
      "epoch: 21 step: 937, loss is 0.43696648\n",
      "epoch: 22 step: 937, loss is 0.17420335\n",
      "epoch: 23 step: 937, loss is 0.2764947\n",
      "epoch: 24 step: 937, loss is 0.2134682\n",
      "epoch: 25 step: 937, loss is 0.38633972\n",
      "epoch: 26 step: 937, loss is 0.25733265\n",
      "epoch: 27 step: 937, loss is 0.22970267\n",
      "epoch: 28 step: 937, loss is 0.37215918\n",
      "epoch: 29 step: 937, loss is 0.19365177\n",
      "epoch: 30 step: 937, loss is 0.21519926\n",
      "{'acc': 0.9221754807692307}\n"
     ]
    }
   ],
   "source": [
    "# 训练有正则化的网络\n",
    "model = train(ForwardFashionRegularization)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "第0个sample预测结果： 2    真实结果： 4\n",
      "第1个sample预测结果： 5    真实结果： 5\n",
      "第2个sample预测结果： 9    真实结果： 9\n",
      "第3个sample预测结果： 9    真实结果： 9\n",
      "第4个sample预测结果： 8    真实结果： 8\n",
      "第5个sample预测结果： 8    真实结果： 8\n",
      "第6个sample预测结果： 3    真实结果： 3\n",
      "第7个sample预测结果： 3    真实结果： 3\n",
      "第8个sample预测结果： 5    真实结果： 5\n",
      "第9个sample预测结果： 8    真实结果： 8\n",
      "第10个sample预测结果： 8    真实结果： 8\n",
      "第11个sample预测结果： 6    真实结果： 2\n",
      "第12个sample预测结果： 6    真实结果： 4\n",
      "第13个sample预测结果： 5    真实结果： 5\n",
      "第14个sample预测结果： 8    真实结果： 8\n"
     ]
    }
   ],
   "source": [
    "# 预测\n",
    "ds_test, _ = create_dataset()\n",
    "test_ = ds_test.create_dict_iterator(output_numpy=True).get_next()\n",
    "predictions = model.predict(Tensor(test_['x']))\n",
    "predictions = predictions.asnumpy()\n",
    "for i in range(15):\n",
    "    p_np = predictions[i, :]\n",
    "    p_list = p_np.tolist()\n",
    "    print('第' + str(i) + '个sample预测结果：', p_list.index(max(p_list)), '   真实结果：', test_['y'][i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# -------------------定义可视化函数--------------------------------\n",
    "# 输入预测结果序列，真实标签序列，以及图片序列\n",
    "# 目标是根据预测值对错，让其标签显示为红色或者蓝色。对：标签为红色；错：标签为蓝色\n",
    "def plot_image(predictions_array, true_label, img):\n",
    "    plt.grid(False)\n",
    "    plt.xticks([])\n",
    "    plt.yticks([])\n",
    "    # 显示对应图片\n",
    "    plt.imshow(img, cmap=plt.cm.binary)\n",
    "    # 显示预测结果的颜色，如果对上了是蓝色，否则为红色\n",
    "    predicted_label = np.argmax(predictions_array)\n",
    "    if predicted_label == true_label:\n",
    "        color = 'blue'\n",
    "    else:\n",
    "        color = 'red'\n",
    "    # 显示对应标签的格式，样式\n",
    "    plt.xlabel('{},{:2.0f}% ({})'.format(class_names[predicted_label],\n",
    "                                         100 * np.max(predictions_array),\n",
    "                                         class_names[true_label]), color=color)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 将预测的结果以柱状图形状显示蓝对红错\n",
    "def plot_value_array(predictions_array, true_label):\n",
    "    plt.grid(False)\n",
    "    plt.xticks([])\n",
    "    plt.yticks([])\n",
    "    this_plot = plt.bar(range(10), predictions_array, color='#777777')\n",
    "    plt.ylim([0, 1])\n",
    "    predicted_label = np.argmax(predictions_array)\n",
    "    this_plot[predicted_label].set_color('red')\n",
    "    this_plot[true_label].set_color('blue')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "def softmax_np(x):\n",
    "    x = x - np.max(x)\n",
    "    exp_x = np.exp(x)\n",
    "    softmax_x = exp_x/np.sum(exp_x)\n",
    "    return softmax_x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x720 with 30 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 预测15个图像与标签，并展现出来\n",
    "num_rows = 5\n",
    "num_cols = 3\n",
    "num_images = num_rows * num_cols\n",
    "plt.figure(figsize=(2 * 2 * num_cols, 2 * num_rows))\n",
    "class_names = ['T-shirt/top', 'Trouser', 'Pullover', 'Dress', 'Coat',\n",
    "               'Sandal', 'Shirt', 'Sneaker', 'Bag', 'Ankle boot']\n",
    "for i in range(num_images):\n",
    "    plt.subplot(num_rows, 2 * num_cols, 2 * i + 1)\n",
    "    pred_np_ = predictions[i, :]\n",
    "    pred_np_ = softmax_np(pred_np_)\n",
    "    plot_image(pred_np_, test_['y'][i], test_['x'][i, 0, ...])\n",
    "    plt.subplot(num_rows, 2 * num_cols, 2 * i + 2)\n",
    "    plot_value_array(pred_np_, test_['y'][i])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Mindspore-1.0.0-python3.7-aarch64",
   "language": "python",
   "name": "mindspore-1.0.0-python3.7-aarch64"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
